and(true, y) → y
and(false, y) → false
eq(nil, nil) → true
eq(cons(t, l), nil) → false
eq(nil, cons(t, l)) → false
eq(cons(t, l), cons(t', l')) → and(eq(t, t'), eq(l, l'))
eq(var(l), var(l')) → eq(l, l')
eq(var(l), apply(t, s)) → false
eq(var(l), lambda(x, t)) → false
eq(apply(t, s), var(l)) → false
eq(apply(t, s), apply(t', s')) → and(eq(t, t'), eq(s, s'))
eq(apply(t, s), lambda(x, t)) → false
eq(lambda(x, t), var(l)) → false
eq(lambda(x, t), apply(t, s)) → false
eq(lambda(x, t), lambda(x', t')) → and(eq(x, x'), eq(t, t'))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))
↳ QTRS
↳ DependencyPairsProof
and(true, y) → y
and(false, y) → false
eq(nil, nil) → true
eq(cons(t, l), nil) → false
eq(nil, cons(t, l)) → false
eq(cons(t, l), cons(t', l')) → and(eq(t, t'), eq(l, l'))
eq(var(l), var(l')) → eq(l, l')
eq(var(l), apply(t, s)) → false
eq(var(l), lambda(x, t)) → false
eq(apply(t, s), var(l)) → false
eq(apply(t, s), apply(t', s')) → and(eq(t, t'), eq(s, s'))
eq(apply(t, s), lambda(x, t)) → false
eq(lambda(x, t), var(l)) → false
eq(lambda(x, t), apply(t, s)) → false
eq(lambda(x, t), lambda(x', t')) → and(eq(x, x'), eq(t, t'))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))
EQ(cons(t, l), cons(t', l')) → EQ(t, t')
EQ(cons(t, l), cons(t', l')) → AND(eq(t, t'), eq(l, l'))
EQ(apply(t, s), apply(t', s')) → EQ(t, t')
REN(var(l), var(k), var(l')) → IF(eq(l, l'), var(k), var(l'))
EQ(cons(t, l), cons(t', l')) → EQ(l, l')
EQ(var(l), var(l')) → EQ(l, l')
EQ(apply(t, s), apply(t', s')) → AND(eq(t, t'), eq(s, s'))
REN(x, y, apply(t, s)) → REN(x, y, s)
EQ(lambda(x, t), lambda(x', t')) → EQ(t, t')
REN(x, y, lambda(z, t)) → REN(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)
REN(var(l), var(k), var(l')) → EQ(l, l')
EQ(lambda(x, t), lambda(x', t')) → EQ(x, x')
REN(x, y, lambda(z, t)) → REN(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t))
EQ(lambda(x, t), lambda(x', t')) → AND(eq(x, x'), eq(t, t'))
EQ(apply(t, s), apply(t', s')) → EQ(s, s')
REN(x, y, apply(t, s)) → REN(x, y, t)
and(true, y) → y
and(false, y) → false
eq(nil, nil) → true
eq(cons(t, l), nil) → false
eq(nil, cons(t, l)) → false
eq(cons(t, l), cons(t', l')) → and(eq(t, t'), eq(l, l'))
eq(var(l), var(l')) → eq(l, l')
eq(var(l), apply(t, s)) → false
eq(var(l), lambda(x, t)) → false
eq(apply(t, s), var(l)) → false
eq(apply(t, s), apply(t', s')) → and(eq(t, t'), eq(s, s'))
eq(apply(t, s), lambda(x, t)) → false
eq(lambda(x, t), var(l)) → false
eq(lambda(x, t), apply(t, s)) → false
eq(lambda(x, t), lambda(x', t')) → and(eq(x, x'), eq(t, t'))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
EQ(cons(t, l), cons(t', l')) → EQ(t, t')
EQ(cons(t, l), cons(t', l')) → AND(eq(t, t'), eq(l, l'))
EQ(apply(t, s), apply(t', s')) → EQ(t, t')
REN(var(l), var(k), var(l')) → IF(eq(l, l'), var(k), var(l'))
EQ(cons(t, l), cons(t', l')) → EQ(l, l')
EQ(var(l), var(l')) → EQ(l, l')
EQ(apply(t, s), apply(t', s')) → AND(eq(t, t'), eq(s, s'))
REN(x, y, apply(t, s)) → REN(x, y, s)
EQ(lambda(x, t), lambda(x', t')) → EQ(t, t')
REN(x, y, lambda(z, t)) → REN(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)
REN(var(l), var(k), var(l')) → EQ(l, l')
EQ(lambda(x, t), lambda(x', t')) → EQ(x, x')
REN(x, y, lambda(z, t)) → REN(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t))
EQ(lambda(x, t), lambda(x', t')) → AND(eq(x, x'), eq(t, t'))
EQ(apply(t, s), apply(t', s')) → EQ(s, s')
REN(x, y, apply(t, s)) → REN(x, y, t)
and(true, y) → y
and(false, y) → false
eq(nil, nil) → true
eq(cons(t, l), nil) → false
eq(nil, cons(t, l)) → false
eq(cons(t, l), cons(t', l')) → and(eq(t, t'), eq(l, l'))
eq(var(l), var(l')) → eq(l, l')
eq(var(l), apply(t, s)) → false
eq(var(l), lambda(x, t)) → false
eq(apply(t, s), var(l)) → false
eq(apply(t, s), apply(t', s')) → and(eq(t, t'), eq(s, s'))
eq(apply(t, s), lambda(x, t)) → false
eq(lambda(x, t), var(l)) → false
eq(lambda(x, t), apply(t, s)) → false
eq(lambda(x, t), lambda(x', t')) → and(eq(x, x'), eq(t, t'))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDPOrderProof
↳ QDP
EQ(var(l), var(l')) → EQ(l, l')
EQ(cons(t, l), cons(t', l')) → EQ(t, t')
EQ(lambda(x, t), lambda(x', t')) → EQ(t, t')
EQ(lambda(x, t), lambda(x', t')) → EQ(x, x')
EQ(apply(t, s), apply(t', s')) → EQ(s, s')
EQ(apply(t, s), apply(t', s')) → EQ(t, t')
EQ(cons(t, l), cons(t', l')) → EQ(l, l')
and(true, y) → y
and(false, y) → false
eq(nil, nil) → true
eq(cons(t, l), nil) → false
eq(nil, cons(t, l)) → false
eq(cons(t, l), cons(t', l')) → and(eq(t, t'), eq(l, l'))
eq(var(l), var(l')) → eq(l, l')
eq(var(l), apply(t, s)) → false
eq(var(l), lambda(x, t)) → false
eq(apply(t, s), var(l)) → false
eq(apply(t, s), apply(t', s')) → and(eq(t, t'), eq(s, s'))
eq(apply(t, s), lambda(x, t)) → false
eq(lambda(x, t), var(l)) → false
eq(lambda(x, t), apply(t, s)) → false
eq(lambda(x, t), lambda(x', t')) → and(eq(x, x'), eq(t, t'))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))
The following pairs can be oriented strictly and are deleted.
The remaining pairs can at least be oriented weakly.
EQ(var(l), var(l')) → EQ(l, l')
EQ(cons(t, l), cons(t', l')) → EQ(t, t')
EQ(lambda(x, t), lambda(x', t')) → EQ(t, t')
EQ(lambda(x, t), lambda(x', t')) → EQ(x, x')
EQ(apply(t, s), apply(t', s')) → EQ(s, s')
EQ(apply(t, s), apply(t', s')) → EQ(t, t')
EQ(cons(t, l), cons(t', l')) → EQ(l, l')
The value of delta used in the strict ordering is 1.
POL(cons(x1, x2)) = 4 + (11/4)x_1 + (4)x_2
POL(apply(x1, x2)) = 4 + (3/2)x_1 + (11/4)x_2
POL(lambda(x1, x2)) = 1 + (7/4)x_1 + (3/2)x_2
POL(EQ(x1, x2)) = (4)x_1
POL(var(x1)) = 1/4 + x_1
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ PisEmptyProof
↳ QDP
and(true, y) → y
and(false, y) → false
eq(nil, nil) → true
eq(cons(t, l), nil) → false
eq(nil, cons(t, l)) → false
eq(cons(t, l), cons(t', l')) → and(eq(t, t'), eq(l, l'))
eq(var(l), var(l')) → eq(l, l')
eq(var(l), apply(t, s)) → false
eq(var(l), lambda(x, t)) → false
eq(apply(t, s), var(l)) → false
eq(apply(t, s), apply(t', s')) → and(eq(t, t'), eq(s, s'))
eq(apply(t, s), lambda(x, t)) → false
eq(lambda(x, t), var(l)) → false
eq(lambda(x, t), apply(t, s)) → false
eq(lambda(x, t), lambda(x', t')) → and(eq(x, x'), eq(t, t'))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPOrderProof
REN(x, y, apply(t, s)) → REN(x, y, s)
REN(x, y, lambda(z, t)) → REN(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)
REN(x, y, lambda(z, t)) → REN(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t))
REN(x, y, apply(t, s)) → REN(x, y, t)
and(true, y) → y
and(false, y) → false
eq(nil, nil) → true
eq(cons(t, l), nil) → false
eq(nil, cons(t, l)) → false
eq(cons(t, l), cons(t', l')) → and(eq(t, t'), eq(l, l'))
eq(var(l), var(l')) → eq(l, l')
eq(var(l), apply(t, s)) → false
eq(var(l), lambda(x, t)) → false
eq(apply(t, s), var(l)) → false
eq(apply(t, s), apply(t', s')) → and(eq(t, t'), eq(s, s'))
eq(apply(t, s), lambda(x, t)) → false
eq(lambda(x, t), var(l)) → false
eq(lambda(x, t), apply(t, s)) → false
eq(lambda(x, t), lambda(x', t')) → and(eq(x, x'), eq(t, t'))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))
The following pairs can be oriented strictly and are deleted.
The remaining pairs can at least be oriented weakly.
REN(x, y, apply(t, s)) → REN(x, y, s)
REN(x, y, apply(t, s)) → REN(x, y, t)
Used ordering: Polynomial interpretation [25,35]:
REN(x, y, lambda(z, t)) → REN(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)
REN(x, y, lambda(z, t)) → REN(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t))
The value of delta used in the strict ordering is 2.
POL(cons(x1, x2)) = 1/2 + (1/4)x_1
POL(if(x1, x2, x3)) = (4)x_3
POL(eq(x1, x2)) = 0
POL(apply(x1, x2)) = 4 + (4)x_1 + (4)x_2
POL(lambda(x1, x2)) = (4)x_2
POL(true) = 4
POL(ren(x1, x2, x3)) = x_3
POL(false) = 0
POL(REN(x1, x2, x3)) = (1/2)x_3
POL(var(x1)) = 0
POL(and(x1, x2)) = 11/4 + (5/4)x_1 + (11/4)x_2
POL(nil) = 4
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ QDPOrderProof
REN(x, y, lambda(z, t)) → REN(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)
REN(x, y, lambda(z, t)) → REN(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t))
and(true, y) → y
and(false, y) → false
eq(nil, nil) → true
eq(cons(t, l), nil) → false
eq(nil, cons(t, l)) → false
eq(cons(t, l), cons(t', l')) → and(eq(t, t'), eq(l, l'))
eq(var(l), var(l')) → eq(l, l')
eq(var(l), apply(t, s)) → false
eq(var(l), lambda(x, t)) → false
eq(apply(t, s), var(l)) → false
eq(apply(t, s), apply(t', s')) → and(eq(t, t'), eq(s, s'))
eq(apply(t, s), lambda(x, t)) → false
eq(lambda(x, t), var(l)) → false
eq(lambda(x, t), apply(t, s)) → false
eq(lambda(x, t), lambda(x', t')) → and(eq(x, x'), eq(t, t'))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))
The following pairs can be oriented strictly and are deleted.
The remaining pairs can at least be oriented weakly.
REN(x, y, lambda(z, t)) → REN(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)
REN(x, y, lambda(z, t)) → REN(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t))
The value of delta used in the strict ordering is 1.
POL(cons(x1, x2)) = 0
POL(if(x1, x2, x3)) = (9/4)x_2 + (4)x_3
POL(eq(x1, x2)) = (3/2)x_1 + (1/2)x_2
POL(apply(x1, x2)) = (1/4)x_1
POL(lambda(x1, x2)) = 1/4 + x_2
POL(true) = 13/4
POL(ren(x1, x2, x3)) = (4)x_2 + x_3
POL(false) = 4
POL(REN(x1, x2, x3)) = (4)x_3
POL(var(x1)) = 0
POL(and(x1, x2)) = 3 + (3/2)x_2
POL(nil) = 0
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ PisEmptyProof
and(true, y) → y
and(false, y) → false
eq(nil, nil) → true
eq(cons(t, l), nil) → false
eq(nil, cons(t, l)) → false
eq(cons(t, l), cons(t', l')) → and(eq(t, t'), eq(l, l'))
eq(var(l), var(l')) → eq(l, l')
eq(var(l), apply(t, s)) → false
eq(var(l), lambda(x, t)) → false
eq(apply(t, s), var(l)) → false
eq(apply(t, s), apply(t', s')) → and(eq(t, t'), eq(s, s'))
eq(apply(t, s), lambda(x, t)) → false
eq(lambda(x, t), var(l)) → false
eq(lambda(x, t), apply(t, s)) → false
eq(lambda(x, t), lambda(x', t')) → and(eq(x, x'), eq(t, t'))
if(true, var(k), var(l')) → var(k)
if(false, var(k), var(l')) → var(l')
ren(var(l), var(k), var(l')) → if(eq(l, l'), var(k), var(l'))
ren(x, y, apply(t, s)) → apply(ren(x, y, t), ren(x, y, s))
ren(x, y, lambda(z, t)) → lambda(var(cons(x, cons(y, cons(lambda(z, t), nil)))), ren(x, y, ren(z, var(cons(x, cons(y, cons(lambda(z, t), nil)))), t)))